/**
 * promise的使用: 是为了避免多层的回调地狱问题.
 */

// let kfc  = new Promise((resolve, reject) => {
//   setTimeout(() => {
//     resolve('kfc餐已经做好了, 请享用')
//   }, 200);
// })

// let dad = kfc.then(data => {
//   console.log(`爸爸已经收到kfc的餐消息:${data}`);
//   return{
//     then(resolve){
//       setTimeout(() => {
//         resolve('我已经吃了2000秒了, 不辣, 儿子你可以吃!')
//       }, 200);
//     }
//   }
// })


// let son = dad.then(msg => {
//   console.log('儿子已经获取到爸爸的消息',`${msg}`);
//   return new Promise((resolve, reject) =>{
//       setTimeout(() => {
//         resolve('我是儿子,我已经吃饱啦!');
//       }, 900);
//   })
// })

// let mon = son.then(data => {
//   console.log(`妈妈收到来自儿子的消息${data}`);
// })


// 传统的回掉函数, 利用回调来力气进行下一个函数的使用,
function notice(msg, then) {
    then(msg);
}

function meal() {
    notice("肯德基厨房开始做饭", msg => {
        console.log(msg);
        notice("我是肯德基，你的餐已经做好", msg => {
            console.log(`收到肯德基消息: ${msg}`);
            setTimeout(() => {
                notice("孩子，我吃了两秒了，不辣，你可以吃了", msg => {
                    console.log(`收到爸爸消息: ${msg}`);
                    setTimeout(() => {
                        notice("妈妈，我和向军爸爸吃完饭了", msg => {
                            console.log(`收到孩子消息: ${msg},事情结束`);
                        });
                    }, 2000);
                });
            }, 2000);
        });
    });
}

// meal();


function note(msg, then) {
    then(msg)
}

note('hahah', msg => {
    console.log(msg);
    return msg
})


let promise = new Promise((resolve, reject) => {
    resolve("fulfilled");
    console.log("后盾人");
});
promise.then(msg => {
    console.log(msg);
});
console.log("houdunren.com");

// 输出顺序: ‘后盾人’ => 'houdunren.com' => 'fulfilled'

console.log(new Promise((resolve, reject) => {
    resolve()
}));

console.log(new Promise((resolve, reject) => {
    reject()
}).catch(err => {
}));


// 链式操作
const p = new Promise((resolve, reject) => {
    resolve('promise')
})

p
    .then(data => {
        console.log(data);
        return {
            then(resolve) {
                resolve('then 1')
            }
        }
    })
    .then(hh => {
        console.log(hh);
        return {
            then(resolve) {
                setTimeout(() => {
                    resolve('then  2')
                }, 1000);
            }
        }
    }).then(data => {
    console.log(data);
    return {
        then(resolve) {
            console.log('then 3');
        }
    }
})

//  console.log('ckckckckck');


// 可以将获取到的数据缓存, 如果有就不走缓存, 如果有就不走网络请求, 就直接走缓存
function query(name) {
    const cache = query.cache || (query.cache = new Map());
    if (cache.has(name)) {
        console.log("走缓存了");
        return Promise.resolve(cache.get(name));
    }
    return ajax(`http://localhost:8888/php/user.php?name=${name}`).then(
        response => {
            cache.set(name, response);
            console.log("没走缓存");
            // 这里的ajax本身就返回的是,promise对象, 所以, 不用进行Promise.resolve()
            return response;
        }
    );
}

// query("向军").then(response => {
//   console.log(response);
// });

// // 这里是模拟的网络处理请求时长.
// setTimeout(() => {
//   query("向军").then(response => {
//     console.log(response);
//   });
// }, 1000);

const newmap = new Map()
newmap.set('hh', 'hah')
newmap.set('90', 90)
newmap.get('hh')
newmap.delete('hh')
console.log(newmap);

// 使用Promise.all方法， 进行等待所有的异步操作完整.
let i = 0
function asyncFun() {
    return new Promise(((resolve, reject) => {
        setTimeout(() => {
            resolve(i += 1)
        }, 1000)
    }))
}

let asyncArr = []
for (let i = 0; i < 10; i++) {
    asyncArr.push(asyncFun())
}
Promise.all(asyncArr).then(data => {
    console.log(data)
})

// Promise可以进行循环的网络请求，为了可以获取到正确的网络请求结果。


